#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
天翼云WebDAV服务主程序

统一入口点，支持WebDAV服务启动、账号管理、系统管理等功能
"""

import os
import sys
import argparse
import socket
from pathlib import Path

# 添加项目根目录到Python路径
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

from src.common.unified_logging import get_logger, init_unified_logging, log_performance, log_error
from src.app import start_webdav_server


def get_network_interfaces():
    """获取网络接口信息"""
    interfaces = []
    
    try:
        # 获取主机名
        hostname = socket.gethostname()
        
        # 获取所有IP地址
        for addr_info in socket.getaddrinfo(hostname, None):
            ip = addr_info[4][0]
            if ip not in ['127.0.0.1', '::1']:  # 排除本地回环地址
                interfaces.append({
                    'ip': ip,
                    'family': 'IPv6' if ':' in ip else 'IPv4',
                    'type': 'External' if not ip.startswith('192.168.') and not ip.startswith('10.') and not ip.startswith('172.') else 'Local'
                })
        
        # 添加本地地址
        interfaces.append({'ip': '127.0.0.1', 'family': 'IPv4', 'type': 'Local'})
        interfaces.append({'ip': '::1', 'family': 'IPv6', 'type': 'Local'})
        
    except Exception as e:
        logger = get_logger('NetworkInfo')
        logger.warning(f"获取网络接口信息失败: {e}")
    
    return interfaces


def display_network_info(host: str, port: int, ipv6: bool = False):
    """显示网络访问信息"""
    logger = get_logger('NetworkInfo')
    
    try:
        logger.info("=" * 60)
        logger.info("网络访问信息")
        logger.info("=" * 60)
        
        if ipv6:
            logger.info(f"IPv6模式: 监听所有IPv6地址 [::]:{port}")
            logger.info("IPv6访问地址:")
            logger.info(f"  - 本地访问: http://[::1]:{port}")
            logger.info(f"  - 所有IPv6: http://[::]:{port}")
        else:
            logger.info(f"IPv4模式: 监听地址 {host}:{port}")
            logger.info("IPv4访问地址:")
            
            if host == "0.0.0.0":
                logger.info(f"  - 本地访问: http://127.0.0.1:{port}")
                
                # 显示可用的网络接口
                interfaces = get_network_interfaces()
                external_interfaces = [iface for iface in interfaces if iface['type'] == 'External']
                local_interfaces = [iface for iface in interfaces if iface['type'] == 'Local']
                
                if external_interfaces:
                    logger.info("  - 外部访问:")
                    for iface in external_interfaces:
                        logger.info(f"    * http://{iface['ip']}:{port} ({iface['family']})")
                
                if local_interfaces:
                    logger.info("  - 本地访问:")
                    for iface in local_interfaces:
                        if iface['ip'] != '127.0.0.1':  # 避免重复显示
                            logger.info(f"    * http://{iface['ip']}:{port} ({iface['family']})")
            else:
                logger.info(f"  - 指定地址: http://{host}:{port}")
        
        logger.info("=" * 60)
        
    except Exception as e:
        logger.warning(f"显示网络信息失败: {e}")


def setup_environment():
    """设置环境"""
    # 初始化统一日志系统
    init_unified_logging("logs", "INFO")
    logger = get_logger('MainScript')
    
    # 加载环境配置
    env_file = project_root / '.env'
    if env_file.exists():
        logger.info(f"已加载环境配置文件: {env_file}")
    else:
        logger.warning("未找到.env配置文件，使用默认配置")
    
    return logger


def start_webdav_service(host: str = "0.0.0.0", port: int = 8080, debug: bool = False, ipv6: bool = False, webdav_path: str = None, enable_cache: bool = True):
    """启动WebDAV服务"""
    logger = get_logger('WebDAVService')
    
    # 如果没有指定webdav_path，尝试从环境变量读取
    if webdav_path is None:
        import os
        webdav_path = os.getenv('WEBDAV_PATH', 'dav')
    
    try:
        # 显示网络访问信息
        display_network_info(host, port, ipv6)
        
        # 根据IPv6选项确定监听地址
        if ipv6:
            listen_host = "::"  # IPv6所有地址
            logger.info("正在启动天翼云WebDAV统一Web服务 (IPv6模式)...")
            logger.info(f"服务地址: http://[{listen_host}]:{port}")
            logger.info(f"WebDAV服务: http://[{listen_host}]:{port}/{webdav_path}/")
            logger.info(f"API文档: http://[{listen_host}]:{port}/docs")
            logger.info(f"管理页面: http://[{listen_host}]:{port}/")
        else:
            listen_host = host
            logger.info("正在启动天翼云WebDAV统一Web服务...")
            logger.info(f"服务地址: http://{listen_host}:{port}")
            logger.info(f"WebDAV服务: http://{listen_host}:{port}/{webdav_path}/")
            logger.info(f"API文档: http://{listen_host}:{port}/docs")
            logger.info(f"管理页面: http://{listen_host}:{port}/")
        
        # 显示缓存状态
        if enable_cache:
            logger.info("✅ 缓存功能: 已启用 (路径缓存: 10000条, 文件夹缓存: 1000条, TTL: 300秒)")
        else:
            logger.info("❌ 缓存功能: 已禁用")
        
        logger.info("测试用户: testuser / testpass123")
        logger.info("按 Ctrl+C 停止服务")
        
        # 启动WebDAV服务器
        start_webdav_server(host=listen_host, port=port, reload=debug, webdav_base_path=f"/{webdav_path}", enable_cache=enable_cache)
        
    except KeyboardInterrupt:
        logger.info("收到中断信号，正在停止服务...")
    except Exception as e:
        log_error('WebDAVService', e, "启动WebDAV服务失败")
        raise


def create_test_user():
    """创建测试用户"""
    logger = get_logger('UserManager')
    
    try:
        from src.common.database import init_global_session
        from src.models.user import WebDAVUser, WebDAVUserRepository
        
        # 初始化数据库
        init_global_session()
        
        # 创建用户仓库
        user_repo = WebDAVUserRepository()
        
        # 检查测试用户是否存在
        existing_user = user_repo.find_by_username("testuser")
        if existing_user:
            logger.info("测试用户已存在")
            return True
        
        # 创建测试用户
        test_user = WebDAVUser(
            username="testuser",
            password="testpass123",  # 实际应用中应该加密
            root_path="/",
            can_read=True,
            can_write=True,
            can_delete=True,
            is_active=True
        )
        
        user_repo.create(test_user)
        logger.info("测试用户创建成功: testuser / testpass123")
        return True
        
    except Exception as e:
        log_error('UserManager', e, "创建测试用户失败")
        return False


def manage_cloud_account(action: str, account: str = None, password: str = None, display_name: str = None):
    """管理云盘账号"""
    logger = get_logger('CloudAccountManager')
    
    try:
        from src.common.database import init_global_session, get_session
        from src.models.cloud import CloudAccount
        
        # 初始化数据库
        init_global_session()
        session = get_session()
        
        if action == "add":
            if not account or not password:
                logger.error("添加账号需要指定 --account 和 --password")
                return False
            
            # 检查账号是否已存在
            existing = session.query(CloudAccount).filter_by(cloud_account=account).first()
            if existing:
                logger.error(f"账号 {account} 已存在")
                return False
            
            # 创建新账号
            new_account = CloudAccount(
                cloud_provider='tianyi',
                cloud_account=account,
                cloud_password=password,
                display_name=display_name or account,
                is_active=True
            )
            
            session.add(new_account)
            session.commit()
            logger.info(f"成功添加云盘账号: {account}")
            return True
            
        elif action == "list":
            accounts = session.query(CloudAccount).filter_by(is_active=True).all()
            if not accounts:
                print("没有找到激活的云盘账号")
                return True
            
            print("云盘账号列表:")
            print("-" * 80)
            print(f"{'ID':<5} {'账号':<20} {'显示名称':<20} {'状态':<8} {'创建时间':<20}")
            print("-" * 80)
            
            for acc in accounts:
                status = "激活" if acc.is_active else "禁用"
                print(f"{acc.id:<5} {acc.cloud_account:<20} {acc.display_name:<20} {status:<8} {acc.created_at.strftime('%Y-%m-%d %H:%M'):<20}")
            
            return True
            
        elif action == "update":
            if not account:
                logger.error("更新账号需要指定 --account")
                return False
            
            # 查找账号
            existing = session.query(CloudAccount).filter_by(cloud_account=account).first()
            if not existing:
                logger.error(f"账号 {account} 不存在")
                return False
            
            # 更新账号信息
            if password:
                existing.cloud_password = password
                logger.info(f"更新账号 {account} 的密码")
            
            if display_name:
                existing.display_name = display_name
                logger.info(f"更新账号 {account} 的显示名称为: {display_name}")
            
            session.commit()
            logger.info(f"成功更新云盘账号: {account}")
            return True
            
        elif action == "remove":
            if not account:
                logger.error("删除账号需要指定 --account")
                return False
            
            # 查找账号
            existing = session.query(CloudAccount).filter_by(cloud_account=account).first()
            if not existing:
                logger.error(f"账号 {account} 不存在")
                return False
            
            # 删除账号
            session.delete(existing)
            session.commit()
            logger.info(f"成功删除云盘账号: {account}")
            return True
        
        session.close()
        
    except Exception as e:
        log_error('CloudAccountManager', e, "云盘账号管理失败")
        return False
    
    return False


def check_dependencies():
    """检查依赖"""
    logger = get_logger('DependencyChecker')
    
    required_modules = [
        'fastapi',
        'uvicorn',
        'sqlalchemy',
        'requests'
    ]
    
    missing_modules = []
    for module in required_modules:
        try:
            __import__(module)
        except ImportError:
            missing_modules.append(module)
    
    if missing_modules:
        logger.error(f"缺少必要模块: {', '.join(missing_modules)}")
        logger.error("请运行: pip install -r requirements.txt")
        return False
    
    logger.info("依赖检查通过")
    return True


def show_system_info():
    """显示系统信息"""
    logger = get_logger('SystemInfo')
    
    try:
        from src.common.database import init_global_session, get_session
        from src.models.cloud import CloudAccount
        
        # 初始化数据库
        init_global_session()
        session = get_session()
        
        # 获取账号统计
        total_accounts = session.query(CloudAccount).count()
        active_accounts = session.query(CloudAccount).filter_by(is_active=True).count()
        
        session.close()
        
        print("\n" + "=" * 60)
        print("天翼云WebDAV服务系统信息")
        print("=" * 60)
        print(f"服务版本: 1.0.0")
        print(f"WebDAV路径: /dav/")
        print(f"总账号数: {total_accounts}")
        print(f"激活账号数: {active_accounts}")
        print(f"支持功能:")
        print(f"  - 文件上传下载")
        print(f"  - 文件移动复制")
        print(f"  - 目录操作")
        print(f"  - 302重定向下载")
        print(f"  - 秒传检测")
        print(f"  - 回收站功能")
        print("=" * 60)
        
        return True
        
    except Exception as e:
        log_error('SystemInfo', e, "获取系统信息失败")
        return False


def main():
    """主函数"""
    parser = argparse.ArgumentParser(
        description='天翼云WebDAV服务统一启动器',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
使用示例:
  python main.py                           # 启动WebDAV服务 (默认监听所有IPv4地址，启用缓存)
  python main.py --debug                   # 调试模式启动
  python main.py --host 0.0.0.0           # 监听所有IPv4地址 (默认)
  python main.py --host 127.0.0.1        # 仅监听本地地址
  python main.py --ipv6                   # 启用IPv6支持 (监听所有IPv6地址)
  python main.py --port 8081              # 使用不同端口
  python main.py --webdav-path files     # 使用自定义WebDAV路径 /files/
  python main.py --webdav-path storage    # 使用自定义WebDAV路径 /storage/
  python main.py --enable-cache           # 启用缓存功能 (默认)
  python main.py --disable-cache          # 禁用缓存功能
  python main.py --create-user            # 创建测试用户
  python main.py --account add --account 13135370346 --password your_password  # 添加云盘账号
  python main.py --account list           # 列出云盘账号
  python main.py --account update --account 13135370346 --password new_password  # 更新账号密码
  python main.py --account remove --account 13135370346  # 删除云盘账号
  python main.py --info                   # 显示系统信息
  python main.py --check-deps             # 检查依赖
        """
    )
    
    # 服务启动参数
    parser.add_argument('--host', default='0.0.0.0', help='服务器主机地址 (默认: 0.0.0.0 支持所有IPv4地址)')
    parser.add_argument('--port', type=int, default=8080, help='服务器端口 (默认: 8080)')
    parser.add_argument('--webdav-path', default='dav', help='WebDAV服务路径前缀 (默认: dav)')
    parser.add_argument('--ipv6', action='store_true', help='启用IPv6支持 (监听 :: 地址)')
    parser.add_argument('--debug', action='store_true', help='启用调试模式')
    
    # 缓存参数
    parser.add_argument('--enable-cache', action='store_true', default=True, help='启用缓存功能 (默认启用)')
    parser.add_argument('--disable-cache', action='store_true', help='禁用缓存功能')
    
    # 用户管理参数
    parser.add_argument('--create-user', action='store_true', help='创建测试用户')
    
    # 云盘账号管理参数
    parser.add_argument('--account', choices=['add', 'list', 'update', 'remove'], help='云盘账号管理操作')
    parser.add_argument('--account-name', help='云盘账号名称')
    parser.add_argument('--password', help='云盘账号密码')
    parser.add_argument('--display-name', help='显示名称')
    
    # 系统管理参数
    parser.add_argument('--info', action='store_true', help='显示系统信息')
    parser.add_argument('--check-deps', action='store_true', help='检查依赖')
    
    args = parser.parse_args()
    
    # 设置环境
    logger = setup_environment()
    
    try:
        # 检查依赖
        if args.check_deps:
            if not check_dependencies():
                return 1
            return 0
        
        # 显示系统信息
        if args.info:
            if not show_system_info():
                return 1
            return 0
        
        # 云盘账号管理
        if args.account:
            if not manage_cloud_account(
                action=args.account,
                account=args.account_name,
                password=args.password,
                display_name=args.display_name
            ):
                return 1
            return 0
        
        # 创建测试用户
        if args.create_user:
            if not create_test_user():
                return 1
            return 0
        
        # 检查依赖
        if not check_dependencies():
            return 1
        
        # 创建测试用户（如果不存在）
        create_test_user()
        
        # 处理缓存参数
        enable_cache = args.enable_cache and not args.disable_cache
        
        # 启动WebDAV服务
        start_webdav_service(
            host=args.host,
            port=args.port,
            debug=args.debug,
            ipv6=args.ipv6,
            webdav_path=args.webdav_path,
            enable_cache=enable_cache
        )
        
        return 0
        
    except Exception as e:
        log_error('MainScript', e, "主程序执行失败")
        return 1


if __name__ == '__main__':
    exit(main())